package com.xiepei.day01;

import java.util.*;

/**
 * 集合学习 - 综合示例
 * 包含：List、Set、Map 的常用操作
 */
public class Test01 {
    public static void main(String[] args) {
        System.out.println("========== 1. List 集合 ==========");
        testList();
        
        System.out.println("\n========== 2. Set 集合 ==========");
        testSet();
        
        System.out.println("\n========== 3. Map 集合 ==========");
        testMap();
        
        System.out.println("\n========== 4. 集合遍历 ==========");
        testTraversal();
    }
    
    /**
     * List 集合测试 - ArrayList
     */
    public static void testList() {
        // 创建 ArrayList
        List<String> list = new ArrayList<>();
        
        // 添加元素
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("张三"); // 允许重复
        
        System.out.println("添加元素后：" + list);
        System.out.println("集合大小：" + list.size());
        
        // 根据索引获取元素
        System.out.println("索引1的元素：" + list.get(1));
        
        // 判断是否包含
        System.out.println("是否包含'李四'：" + list.contains("李四"));
        
        // 删除元素
        list.remove("张三"); // 删除第一个匹配的元素
        System.out.println("删除'张三'后：" + list);
        
        // 遍历方式1：普通for循环
        System.out.print("普通for循环：");
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
        }
        System.out.println();
        
        // 遍历方式2：增强for循环
        System.out.print("增强for循环：");
        for (String name : list) {
            System.out.print(name + " ");
        }
        System.out.println();
        
        // 遍历方式3：迭代器
        System.out.print("迭代器遍历：");
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
        System.out.println();
    }
    
    /**
     * Set 集合测试 - HashSet
     */
    public static void testSet() {
        // 创建 HashSet
        Set<String> set = new HashSet<>();
        
        // 添加元素
        set.add("苹果");
        set.add("香蕉");
        set.add("橘子");
        set.add("苹果"); // 重复元素，不会添加
        
        System.out.println("添加元素后：" + set);
        System.out.println("集合大小：" + set.size());
        
        // 判断是否包含
        System.out.println("是否包含'香蕉'：" + set.contains("香蕉"));
        
        // 删除元素
        set.remove("橘子");
        System.out.println("删除'橘子'后：" + set);
        
        // 遍历Set（只能用增强for或迭代器，没有索引）
        System.out.print("增强for循环：");
        for (String fruit : set) {
            System.out.print(fruit + " ");
        }
        System.out.println();
        
        // TreeSet 示例（自动排序）
        Set<Integer> treeSet = new TreeSet<>();
        treeSet.add(5);
        treeSet.add(2);
        treeSet.add(8);
        treeSet.add(1);
        System.out.println("TreeSet（自动排序）：" + treeSet);
    }
    
    /**
     * Map 集合测试 - HashMap
     */
    public static void testMap() {
        // 创建 HashMap
        Map<String, Integer> map = new HashMap<>();
        
        // 添加键值对
        map.put("张三", 20);
        map.put("李四", 22);
        map.put("王五", 25);
        map.put("张三", 21); // 键重复，会覆盖原来的值
        
        System.out.println("添加元素后：" + map);
        System.out.println("集合大小：" + map.size());
        
        // 根据键获取值
        System.out.println("张三的年龄：" + map.get("张三"));
        
        // 判断是否包含键
        System.out.println("是否包含键'李四'：" + map.containsKey("李四"));
        
        // 判断是否包含值
        System.out.println("是否包含值25：" + map.containsValue(25));
        
        // 删除键值对
        map.remove("王五");
        System.out.println("删除'王五'后：" + map);
        
        // 获取所有键
        Set<String> keys = map.keySet();
        System.out.println("所有键：" + keys);
        
        // 获取所有值
        Collection<Integer> values = map.values();
        System.out.println("所有值：" + values);
        
        // TreeMap 示例（按键自动排序）
        Map<String, Integer> treeMap = new TreeMap<>();
        treeMap.put("zhao", 30);
        treeMap.put("wang", 25);
        treeMap.put("li", 28);
        System.out.println("TreeMap（按键排序）：" + treeMap);
    }
    
    /**
     * 集合遍历方式演示
     */
    public static void testTraversal() {
        List<String> list = Arrays.asList("A", "B", "C", "D");
        
        // 1. 普通for循环（只有List支持）
        System.out.print("1. 普通for循环：");
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
        }
        System.out.println();
        
        // 2. 增强for循环（所有集合都支持）
        System.out.print("2. 增强for循环：");
        for (String item : list) {
            System.out.print(item + " ");
        }
        System.out.println();
        
        // 3. 迭代器（所有集合都支持）
        System.out.print("3. 迭代器遍历：");
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
        System.out.println();
        
        // 4. Map 的遍历方式
        Map<String, Integer> map = new HashMap<>();
        map.put("语文", 90);
        map.put("数学", 85);
        map.put("英语", 88);
        
        // 方式1：通过 keySet 遍历
        System.out.print("4. Map遍历（keySet）：");
        for (String key : map.keySet()) {
            System.out.print(key + "=" + map.get(key) + " ");
        }
        System.out.println();
        
        // 方式2：通过 entrySet 遍历（推荐）
        System.out.print("5. Map遍历（entrySet）：");
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.print(entry.getKey() + "=" + entry.getValue() + " ");
        }
        System.out.println();
    }
}
